angular.service(ꞌvisibilityꞌ) - Code Metrics - Inspection of "Subatomic boosts included" - angarg12/nucleogenesis - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( fd138b...6abab4 )

by Andres

created 2017-07-16 18:14 UTC

angular.service(ꞌvisibilityꞌ) B

↳ Parent: src/scripts/services/visibility.js

Complexity

Conditions	1
Paths	2

Size

Total Lines

216

Duplication

Lines	0
Ratio	0 %

Importance

Changes	7
Bugs	0	Features	0

Metric	Value
cc	1
c	7
b	0
f	0
nc	2
dl	0
loc	216
rs	8.2857
nop	2

27 Functions

Rating	Name	Size	Complexity
A	��)	3	1
A	��)	3	1
A	��)	3	1
A	��)	3	1
A	��)	3	1
A	��)	11	4
A	��)	3	1
A	��)	3	1
B	��)	20	5
A	��)	3	1
A	��)	13	4
A	��)	3	1
A	��)	8	3
A	��)	10	3
A	��)	11	4
C	��)	25	8
A	��)	3	1
A	��)	3	1
A	��)	3	1
A	��)	3	1
A	��)	12	4
A	��)	5	2
B	��)	14	5
A	��)	3	1
A	��)	3	1
A	��)	9	3
A	��)	3	1

How to fix Long Method

'use strict';

angular
  .module('game')
  .service('visibility', ['state',
    'data',
    function(state, data) {
      let newElements = [];

      function visible(items, func, currentElement) {
        let visibles = [];
        for (let i in items) {
          // if it is an array, we need to extract the item from the index
          let item = Array.isArray(items) ? items[i] : i;
          if (func(item, currentElement)) {
            visibles.push(item);
          }
        }
        return visibles;
      }

      this.visibleElements = function() {
        return visible(data.elements, isElementVisible);
      };

      this.visibleGenerators = function(currentElement) {
        return visible(data.generators, isGeneratorVisible, currentElement);
      };

      this.visibleUpgrades = function(currentElement) {
        return visible(data.upgrades, isBasicUpgradeVisible, currentElement);
      };

      this.visibleExoticUpgrades = function(currentElement) {
        return visible(data.exotic_upgrades, isExoticUpgradeVisible, currentElement);
      };

      this.visibleDarkUpgrades = function(currentElement) {
        return visible(data.dark_upgrades, isDarkUpgradeVisible, currentElement);
      };

      this.visibleResources = function(currentElement, type) {
        let resources = visible(data.resources, isResourceVisible, currentElement);
        if(type){
          let filteredResources = [];
          for(let resource of resources){
            if(data.resources[resource].type &&
               data.resources[resource].type.indexOf(type) !== -1){
                filteredResources.push(resource);
            }
          }
          return filteredResources;
        }
        return resources;
      };

      this.visibleEncyclopediaEntries = function() {
        return visible(data.encyclopedia, isEncyclopediaEntryVisible);
      };

      this.visibleRedox = function(currentElement) {
        return visible(state.player.redox, isRedoxVisible, currentElement);
      };

      this.visibleSyntheses = function(currentElement) {
        return visible(data.reactions, isSynthesisVisible, currentElement);
      };

      function isElementVisible(element) {
        if (data.elements[element].disabled) {
          return false;
        }

        for (let resource of data.elements[element].includes) {
          if (state.player.resources[resource].unlocked) {
            return true;
          }
        }

        return false;
      }

      function isGeneratorVisible(name, currentElement) {
        let generator = data.generators[name];
        for (let dep of generator.deps) {
          if (state.player.elements[currentElement].generators[dep] === 0) {
            return false;
          }
        }

        return true;
      }

      function isBasicUpgradeVisible(name, currentElement) {
        return isUpgradeVisible(name, currentElement, data.upgrades[name]);
      }

      function isExoticUpgradeVisible(name, currentElement) {
        return isUpgradeVisible(name, currentElement, data.exotic_upgrades[name]);
      }

      function isDarkUpgradeVisible(name, currentElement) {
        return isUpgradeVisible(name, currentElement, data.dark_upgrades[name]);
      }

      function meetDependencies(upgrades, dependencies) {
        if (!dependencies) {
          return true;
        }
        for (let dep of dependencies) {
          if (!upgrades[dep]) {
            return false;
          }
        }
        return true;
      }

      function isUpgradeVisible(name, currentElement, upgrade) {
        if (upgrade.tiers) {
          for (let tier of upgrade.tiers) {
            if (state.player.elements[currentElement].generators[tier] === 0) {
              return false;
            }
          }
        }
        return meetDependencies(state.player.elements[currentElement].upgrades, upgrade.deps) &&
          meetDependencies(state.player.elements[currentElement].exotic_upgrades, upgrade.exotic_deps) &&
          meetDependencies(state.player.dark_upgrades, upgrade.dark_deps);
      }

      function isResourceVisible(name, currentElement) {
        if (!state.player.resources[name].unlocked) {
          return false;
        }

        // This is for global resources e.g. protons, which do not
        // belong to any element
        let elements = data.resources[name].elements;
        if (Object.keys(elements).length === 0) {
          return true;
        }

        for (let element in elements) {
          if (currentElement === element) {
            return true;
          }
        }

        return false;
      }

      function isEncyclopediaEntryVisible(entry) {
        return state.player.achievements[entry];
      }

      function isReactionVisible(entry, currentElement, reaction) {
        if (!state.player.achievements[reaction]) {
          return false;
        }

        for (let reactant in entry.reactant) {
          if (!state.player.resources[reactant].unlocked) {
            return false;
          }
        }

        // for misc reactions
        if(entry.elements.length === 0 &&
           currentElement === ''){
             return true;
        }

        for (let element in entry.elements) {
          if (currentElement === entry.elements[element]) {
            return true;
          }
        }

        return false;
      }

      function isRedoxVisible(entry, currentElement) {
        return entry.element === currentElement;
      }

      function isSynthesisVisible(entry, currentElement) {
        return isReactionVisible(data.reactions[entry], currentElement, 'reaction');
      }

      this.elementHasNew = function(element) {
        let includes = data.elements[element].includes;
        for (let key in includes) {
          if (this.hasNew(includes[key])) {
            return true;
          }
        }
        return false;
      };

      this.encyclopediaHasNew = function() {
        for (let entry in data.encyclopedia) {
          if (this.hasNew(entry)) {
            return true;
          }
        }
        return false;
      };

      this.hasNew = function(entry) {
        return newElements.indexOf(entry) !== -1;
      };

      this.addNew = function(entry) {
        newElements.push(entry);
      };

      this.removeNew = function(entry) {
        if (newElements.indexOf(entry) !== -1) {
          newElements.splice(newElements.indexOf(entry), 1);
        }
      };
    }
  ]);


1			'use strict';
2
3			angular
4			.module('game')
5			.service('visibility', ['state',
6			'data',
7			function(state, data) {
8			let newElements = [];
9
10			function visible(items, func, currentElement) {
11			let visibles = [];
12			for (let i in items) {
13			// if it is an array, we need to extract the item from the index
14			let item = Array.isArray(items) ? items[i] : i;
15			if (func(item, currentElement)) {
16			visibles.push(item);
17			}
18			}
19			return visibles;
20			}
21
22			this.visibleElements = function() {
23			return visible(data.elements, isElementVisible);
24			};
25
26			this.visibleGenerators = function(currentElement) {
27			return visible(data.generators, isGeneratorVisible, currentElement);
28			};
29
30			this.visibleUpgrades = function(currentElement) {
31			return visible(data.upgrades, isBasicUpgradeVisible, currentElement);
32			};
33
34			this.visibleExoticUpgrades = function(currentElement) {
35			return visible(data.exotic_upgrades, isExoticUpgradeVisible, currentElement);
36			};
37
38			this.visibleDarkUpgrades = function(currentElement) {
39			return visible(data.dark_upgrades, isDarkUpgradeVisible, currentElement);
40			};
41
42			this.visibleResources = function(currentElement, type) {
43			let resources = visible(data.resources, isResourceVisible, currentElement);
44			if(type){
45			let filteredResources = [];
46			for(let resource of resources){
47			if(data.resources[resource].type &&
48			data.resources[resource].type.indexOf(type) !== -1){
49			filteredResources.push(resource);
50			}
51			}
52			return filteredResources;
53			}
54			return resources;
55			};
56
57			this.visibleEncyclopediaEntries = function() {
58			return visible(data.encyclopedia, isEncyclopediaEntryVisible);
59			};
60
61			this.visibleRedox = function(currentElement) {
62			return visible(state.player.redox, isRedoxVisible, currentElement);
63			};
64
65			this.visibleSyntheses = function(currentElement) {
66			return visible(data.reactions, isSynthesisVisible, currentElement);
67			};
68
69			function isElementVisible(element) {
70			if (data.elements[element].disabled) {
71			return false;
72			}
73
74			for (let resource of data.elements[element].includes) {
75			if (state.player.resources[resource].unlocked) {
76			return true;
77			}
78			}
79
80			return false;
81			}
82
83			function isGeneratorVisible(name, currentElement) {
84			let generator = data.generators[name];
85			for (let dep of generator.deps) {
86			if (state.player.elements[currentElement].generators[dep] === 0) {
87			return false;
88			}
89			}
90
91			return true;
92			}
93
94			function isBasicUpgradeVisible(name, currentElement) {
95			return isUpgradeVisible(name, currentElement, data.upgrades[name]);
96			}
97
98			function isExoticUpgradeVisible(name, currentElement) {
99			return isUpgradeVisible(name, currentElement, data.exotic_upgrades[name]);
100			}
101
102			function isDarkUpgradeVisible(name, currentElement) {
103			return isUpgradeVisible(name, currentElement, data.dark_upgrades[name]);
104			}
105
106			function meetDependencies(upgrades, dependencies) {
107			if (!dependencies) {
108			return true;
109			}
110			for (let dep of dependencies) {
111			if (!upgrades[dep]) {
112			return false;
113			}
114			}
115			return true;
116			}
117
118			function isUpgradeVisible(name, currentElement, upgrade) {
119			if (upgrade.tiers) {
120			for (let tier of upgrade.tiers) {
121			if (state.player.elements[currentElement].generators[tier] === 0) {
122			return false;
123			}
124			}
125			}
126			return meetDependencies(state.player.elements[currentElement].upgrades, upgrade.deps) &&
127			meetDependencies(state.player.elements[currentElement].exotic_upgrades, upgrade.exotic_deps) &&
128			meetDependencies(state.player.dark_upgrades, upgrade.dark_deps);
129			}
130
131			function isResourceVisible(name, currentElement) {
132			if (!state.player.resources[name].unlocked) {
133			return false;
134			}
135
136			// This is for global resources e.g. protons, which do not
137			// belong to any element
138			let elements = data.resources[name].elements;
139			if (Object.keys(elements).length === 0) {
140			return true;
141			}
142
143			for (let element in elements) {
144			if (currentElement === element) {
145			return true;
146			}
147			}
148
149			return false;
150			}
151
152			function isEncyclopediaEntryVisible(entry) {
153			return state.player.achievements[entry];
154			}
155
156			function isReactionVisible(entry, currentElement, reaction) {
157			if (!state.player.achievements[reaction]) {
158			return false;
159			}
160
161			for (let reactant in entry.reactant) {
162			if (!state.player.resources[reactant].unlocked) {
163			return false;
164			}
165			}
166
167			// for misc reactions
168			if(entry.elements.length === 0 &&
169			currentElement === ''){
170			return true;
171			}
172
173			for (let element in entry.elements) {
174			if (currentElement === entry.elements[element]) {
175			return true;
176			}
177			}
178
179			return false;
180			}
181
182			function isRedoxVisible(entry, currentElement) {
183			return entry.element === currentElement;
184			}
185
186			function isSynthesisVisible(entry, currentElement) {
187			return isReactionVisible(data.reactions[entry], currentElement, 'reaction');
188			}
189
190			this.elementHasNew = function(element) {
191			let includes = data.elements[element].includes;
192			for (let key in includes) {
193			if (this.hasNew(includes[key])) {
194			return true;
195			}
196			}
197			return false;
198			};
199
200			this.encyclopediaHasNew = function() {
201			for (let entry in data.encyclopedia) {
202			if (this.hasNew(entry)) {
203			return true;
204			}
205			}
206			return false;
207			};
208
209			this.hasNew = function(entry) {
210			return newElements.indexOf(entry) !== -1;
211			};
212
213			this.addNew = function(entry) {
214			newElements.push(entry);
215			};
216
217			this.removeNew = function(entry) {
218			if (newElements.indexOf(entry) !== -1) {
219			newElements.splice(newElements.indexOf(entry), 1);
220			}
221			};
222			}
223			]);
224

angarg12 / nucleogenesis

Push — master ( fd138b...6abab4 )

angular.service(ꞌvisibilityꞌ) B

Complexity

Size

Duplication

Importance

27 Functions

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like